/*
 *  linux/kernel/fork.c
 *
 *  (C) 1991  Linus Torvalds
 */

/*
 *  'fork.c' contains the help-routines for the 'fork' system call
 * (see also system_call.s), and some misc functions ('verify_area').
 * Fork is rather simple, once you get the hang of it, but the memory
 * management can be a bitch. See 'mm/mm.c': 'copy_page_tables()'
 */
#include <errno.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <asm/system.h>

extern void write_verify(unsigned long address);

long last_pid=0;

void verify_area(void * addr,int size)
{
	unsigned long start;

	start = (unsigned long) addr;
	size += start & 0xfff;
	start &= 0xfffff000;
	start += get_base(current->ldt[2]);
	while (size>0) {
		size -= 4096;
		write_verify(start);
		start += 4096;
	}
}

int copy_mem(int nr,struct task_struct * p)
{
    // 局部描述符表 LDT 赋值
	unsigned long old_data_base,new_data_base,data_limit;
	unsigned long old_code_base,new_code_base,code_limit;

    // get_limit() 和 get_base()
    // 通过 lsl 和 lar 汇编指令从 GDT/LDT 中读取段描述符的限长和基址
    // 段选择符：
    // 0x0f：内核代码段（CPL=0，RPL=3）。
    // 0x17：内核数据段（CPL=0，RPL=3）

	code_limit=get_limit(0x0f);// 获取代码段限长（GDT 中 0x0f 是内核代码段）
	data_limit=get_limit(0x17); // 获取数据段限长（GDT 中 0x17 是内核数据段）
	old_code_base = get_base(current->ldt[1]);// 父进程代码段基址（LDT 第1项）
	old_data_base = get_base(current->ldt[2]);// 父进程数据段基址（LDT 第2项）
	if (old_data_base != old_code_base)
		panic("We don't support separate I&D");
	if (data_limit < code_limit)
		panic("Bad data_limit");
    // 设置子进程的段基址
    // 基址计算：
    // 每个进程的地址空间基址为 PID * 64MB（如 PID=1 的基址是 0x4000000）。
    // 这种设计简单但限制最大进程数（如 4GB/64MB = 64 个进程）。
    // set_base()：
    // 修改 LDT 描述符中的基址字段（通过 lldt 指令加载新 LDT）。
	new_data_base = new_code_base = nr * 0x4000000; // 基址 = PID * 64MB
	p->start_code = new_code_base;
	set_base(p->ldt[1],new_code_base); // 设置子进程代码段基址（LDT 第1项）
	set_base(p->ldt[2],new_data_base); // 设置子进程数据段基址（LDT 第2项）
    // 拷贝页表
    //  // old=0, new=64M, limit=640K
	if (copy_page_tables(old_data_base,new_data_base,data_limit)) {
		free_page_tables(new_data_base,data_limit);
		return -ENOMEM;
	}
	return 0;
}

/*
 *  Ok, this is the main fork-routine. It copies the system process
 * information (task[nr]) and sets up the necessary registers. It
 * also copies the data segment in it's entirety.
 */
int copy_process(int nr,long ebp,long edi,long esi,long gs,long none,
		long ebx,long ecx,long edx,
		long fs,long es,long ds,
		long eip,long cs,long eflags,long esp,long ss)
{
	struct task_struct *p;
	int i;
	struct file *f;

    // get_free_page 这个函数就很简单了，就是遍历 mem_map[] 这个数组，找出值为零的项，就表示找到了空闲的一页内存。
    // 然后把该项置为 1，表示该页已经被使用。最后，算出这个页的内存起始地址，返回。
    //
    //然后，拿到的这个内存起始地址，就给了 task_struct 结构的 p
	p = (struct task_struct *) get_free_page();
	if (!p)
		return -EAGAIN;
	task[nr] = p;
	*p = *current;	/* NOTE! this doesn't copy the supervisor stack */
	p->state = TASK_UNINTERRUPTIBLE;
	p->pid = last_pid;
	p->father = current->pid;
	p->counter = p->priority;
	p->signal = 0;
	p->alarm = 0;
	p->leader = 0;		/* process leadership doesn't inherit */
	p->utime = p->stime = 0;
	p->cutime = p->cstime = 0;
	p->start_time = jiffies;
	p->tss.back_link = 0;
	p->tss.esp0 = PAGE_SIZE + (long) p;
	p->tss.ss0 = 0x10;
	p->tss.eip = eip;
	p->tss.eflags = eflags;
    // 子进程的 tss.eax 被强制设为 0
	p->tss.eax = 0;
	p->tss.ecx = ecx;
	p->tss.edx = edx;
	p->tss.ebx = ebx;
	p->tss.esp = esp;
	p->tss.ebp = ebp;
	p->tss.esi = esi;
	p->tss.edi = edi;
	p->tss.es = es & 0xffff;
	p->tss.cs = cs & 0xffff;
	p->tss.ss = ss & 0xffff;
	p->tss.ds = ds & 0xffff;
	p->tss.fs = fs & 0xffff;
	p->tss.gs = gs & 0xffff;
	p->tss.ldt = _LDT(nr);
	p->tss.trace_bitmap = 0x80000000;
	if (last_task_used_math == current)
		__asm__("clts ; fnsave %0"::"m" (p->tss.i387));
	if (copy_mem(nr,p)) {
		task[nr] = NULL;
		free_page((long) p);
		return -EAGAIN;
	}
	for (i=0; i<NR_OPEN;i++)
		if (f=p->filp[i])
			f->f_count++;
	if (current->pwd)
		current->pwd->i_count++;
	if (current->root)
		current->root->i_count++;
	if (current->executable)
		current->executable->i_count++;
	set_tss_desc(gdt+(nr<<1)+FIRST_TSS_ENTRY,&(p->tss));
	set_ldt_desc(gdt+(nr<<1)+FIRST_LDT_ENTRY,&(p->ldt));
	p->state = TASK_RUNNING;	/* do this last, just in case */
    // 父进程返回子进程 PID（通过 eax 传递）
	return last_pid;
}

// 找到空闲的进程槽位
int find_empty_process(void)
{
	int i;

	repeat:
    // 判断 ++last_pid 是不是小于零了，小于零说明已经超过 long 的最大值了，重新赋值为 1，起到一个保护作用，这没什么好说的。
		if ((++last_pid)<0) last_pid=1;
        // 一个 for 循环，看看刚刚的 last_pid 在所有 task[] 数组中，是否已经被某进程占用了。
        // 如果被占用了，那就重复执行，再次加一，然后再次判断，直到找到一个 pid 号没有被任何进程用为止。
		for(i=0 ; i<NR_TASKS ; i++)
			if (task[i] && task[i]->pid == last_pid) goto repeat;
        // 又是个 for 循环，刚刚已经找到一个可用的 pid 号了，那这一步就是再次遍历这个 task[] 试图找到一个空闲项，找到了就返回素组索引下标。
	for(i=1 ; i<NR_TASKS ; i++)
		if (!task[i])
            // 由于我们现在只有 0 号进程，且 task[] 除了 0 号索引位置，其他地方都是空的，
            // 所以这个方法运行完，last_pid 就是 1，也就是新进程被分配的 pid 就是 1，然后即将要加入的 task[] 数组的索引位置，也是 1
			return i;
	return -EAGAIN;
}
